{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "86b44172-7131-44a3-a825-ac6a7347b7a7",
   "metadata": {},
   "source": [
    "# TNT-LLM: Text Mining at Scale\n",
    "\n",
    "[TNT-LLM](https://arxiv.org/abs/2403.12173) by Wan, et. al describes a taxonomy generation and classification system developed by Microsoft for their Bing Copilot application.\n",
    "\n",
    "It generates a rich, interpretable taxonomy of user intents (or other categories) from raw conversation logs. This taxonomy can then be used downstream by LLMs to label logs, which in turn can be used as training data to adapt a cheap classifier (such as logistic regression classifier on embeddings) that can be deployed in your app.\n",
    "\n",
    "TNT-LLM has three main phases:\n",
    "\n",
    "1. Generate Taxonomy\n",
    "2. Label Training Data\n",
    "3. Finetune classifier + deploy\n",
    "\n",
    "When applying LangGraph in this notebook, we will focus on the first phase: taxonomy generation (blue in the diagram below). We then show how to label and fit the classifier in subsequent steps below.\n",
    "\n",
    "![TNT LLM Diagram](./img/tnt_llm.png)\n",
    "\n",
    "To generate the taxonomy, TNT-LLM proposes 5 steps:\n",
    "\n",
    "1. **Summarize** chat logs using a lower-cost LLM (batched over all logs in the sample)\n",
    "2. **Batch** the logs into random minibatches\n",
    "3. **Generate** an initial taxonomy from the first minibatch\n",
    "4. **Update** the taxonomy on each subsequent minibatch via a ritique and revise prompt\n",
    "5. **Review** the final taxonomy, scoring its quality and generating a final value using a final sample.\n",
    "\n",
    "## Prerequisites\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abd95235-4da5-4d6a-985f-78b2572ad626",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr\n",
    "%pip install -U langgraph langchain_anthropic langsmith\n",
    "# For the embedding-based classifier use in phase 2\n",
    "%pip install -U sklearn langchain_openai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d98b62e4-d327-4442-8482-65529500a8a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from getpass import getpass\n",
    "\n",
    "if \"ANTHROPIC_API_KEY\" not in os.environ:\n",
    "    os.environ[\"ANTHROPIC_API_KEY\"] = getpass(\"Enter your ANTHROPIC_API_KEY: \")\n",
    "\n",
    "# (Optional) Enable tracing\n",
    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
    "os.environ[\"LANGCHAIN_PROJECT\"] = \"tnt-llm\"\n",
    "\n",
    "if \"LANGCHAIN_API_KEY\" not in os.environ:\n",
    "    os.environ[\"LANGCHAIN_API_KEY\"] = getpass(\"Enter your LANGCHAIN_API_KEY: \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04a133e8-f94d-4ae4-8ee1-6bee09dad4fd",
   "metadata": {},
   "source": [
    "#### Graph State\n",
    "\n",
    "Since each node of a StateGraph accepts the state (and returns an updated state), we'll define that at the outset.\n",
    "\n",
    "Our flow takes in a list of documents, batches them, and then generates and refines candidate taxonomies as interpretable \"clusters\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "580d82b5-b60c-47a4-9c8b-e28be22ca0e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import operator\n",
    "from typing import Annotated, List, Optional, TypedDict\n",
    "\n",
    "logging.basicConfig(level=logging.WARNING)\n",
    "logger = logging.getLogger(\"tnt-llm\")\n",
    "\n",
    "\n",
    "class Doc(TypedDict):\n",
    "    id: str\n",
    "    content: str\n",
    "    summary: Optional[str]\n",
    "    explanation: Optional[str]\n",
    "    category: Optional[str]\n",
    "\n",
    "\n",
    "class TaxonomyGenerationState(TypedDict):\n",
    "    # The raw docs; we inject summaries within them in the first step\n",
    "    documents: List[Doc]\n",
    "    # Indices to be concise\n",
    "    minibatches: List[List[int]]\n",
    "    # Candidate Taxonomies (full trajectory)\n",
    "    clusters: Annotated[List[List[dict]], operator.add]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e13d0b3-03a5-4584-98e4-b06cbb446e35",
   "metadata": {},
   "source": [
    "#### 1. Summarize Docs\n",
    "\n",
    "Chat logs can get quite long. Our taxonomy generation step needs to see large, diverse minibatches to be able to adequately capture the distribution of categories. To ensure they can all fit efficiently into the context window, we first summarize each chat log. Downstream steps will use these summaries instead of the raw doc content.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ff02c2a1-18b5-4848-96bb-27ff00978570",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "from langchain import hub\n",
    "from langchain_anthropic import ChatAnthropic\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "from langchain_core.runnables import RunnableConfig, RunnableLambda, RunnablePassthrough\n",
    "\n",
    "summary_prompt = hub.pull(\"wfh/tnt-llm-summary-generation\").partial(\n",
    "    summary_length=20, explanation_length=30\n",
    ")\n",
    "\n",
    "\n",
    "def parse_summary(xml_string: str) -> dict:\n",
    "    summary_pattern = r\"<summary>(.*?)</summary>\"\n",
    "    explanation_pattern = r\"<explanation>(.*?)</explanation>\"\n",
    "\n",
    "    summary_match = re.search(summary_pattern, xml_string, re.DOTALL)\n",
    "    explanation_match = re.search(explanation_pattern, xml_string, re.DOTALL)\n",
    "\n",
    "    summary = summary_match.group(1).strip() if summary_match else \"\"\n",
    "    explanation = explanation_match.group(1).strip() if explanation_match else \"\"\n",
    "\n",
    "    return {\"summary\": summary, \"explanation\": explanation}\n",
    "\n",
    "\n",
    "summary_llm_chain = (\n",
    "    summary_prompt\n",
    "    | ChatAnthropic(model=\"claude-3-haiku-20240307\")\n",
    "    | StrOutputParser()\n",
    "    # Customize the tracing name for easier organization\n",
    ").with_config(run_name=\"GenerateSummary\")\n",
    "summary_chain = summary_llm_chain | parse_summary\n",
    "\n",
    "\n",
    "# Now combine as a \"map\" operation in a map-reduce chain\n",
    "# Input: state\n",
    "# Output: state U summaries\n",
    "# Processes docs in parallel\n",
    "def get_content(state: TaxonomyGenerationState):\n",
    "    docs = state[\"documents\"]\n",
    "    return [{\"content\": doc[\"content\"]} for doc in docs]\n",
    "\n",
    "\n",
    "map_step = RunnablePassthrough.assign(\n",
    "    summaries=get_content\n",
    "    # This effectively creates a \"map\" operation\n",
    "    # Note you can make this more robust by handling individual errors\n",
    "    | RunnableLambda(func=summary_chain.batch, afunc=summary_chain.abatch)\n",
    ")\n",
    "\n",
    "\n",
    "def reduce_summaries(combined: dict) -> TaxonomyGenerationState:\n",
    "    summaries = combined[\"summaries\"]\n",
    "    documents = combined[\"documents\"]\n",
    "    return {\n",
    "        \"documents\": [\n",
    "            {\n",
    "                \"id\": doc[\"id\"],\n",
    "                \"content\": doc[\"content\"],\n",
    "                \"summary\": summ_info[\"summary\"],\n",
    "                \"explanation\": summ_info[\"explanation\"],\n",
    "            }\n",
    "            for doc, summ_info in zip(documents, summaries)\n",
    "        ]\n",
    "    }\n",
    "\n",
    "\n",
    "# This is actually the node itself!\n",
    "map_reduce_chain = map_step | reduce_summaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "654cbad5-3af9-4c16-9d43-cbb903957944",
   "metadata": {},
   "source": [
    "#### 2. Split into Minibatches\n",
    "\n",
    "Each minibatch contains a random sample of docs. This lets the flow identify inadequacies in the current taxonomy using new data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3e0139c3-b5ba-42b9-9367-33533d66eb58",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def get_minibatches(state: TaxonomyGenerationState, config: RunnableConfig):\n",
    "    batch_size = config[\"configurable\"].get(\"batch_size\", 200)\n",
    "    original = state[\"documents\"]\n",
    "    indices = list(range(len(original)))\n",
    "    random.shuffle(indices)\n",
    "    if len(indices) < batch_size:\n",
    "        # Don't pad needlessly if we can't fill a single batch\n",
    "        return [indices]\n",
    "\n",
    "    num_full_batches = len(indices) // batch_size\n",
    "\n",
    "    batches = [\n",
    "        indices[i * batch_size : (i + 1) * batch_size] for i in range(num_full_batches)\n",
    "    ]\n",
    "\n",
    "    leftovers = len(indices) % batch_size\n",
    "    if leftovers:\n",
    "        last_batch = indices[num_full_batches * batch_size :]\n",
    "        elements_to_add = batch_size - leftovers\n",
    "        last_batch += random.sample(indices, elements_to_add)\n",
    "        batches.append(last_batch)\n",
    "\n",
    "    return {\n",
    "        \"minibatches\": batches,\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ca9ca18-f43a-46bd-bd28-7bec90932dd9",
   "metadata": {},
   "source": [
    "#### 3.a Taxonomy Generation Utilities\n",
    "\n",
    "This section of the graph is a generate -> update 🔄 -> review cycle. Each node shares a LOT of logic, which we have factored out into the shared functions below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "224ed013-2963-489c-b734-315cad701d59",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict\n",
    "\n",
    "from langchain_core.runnables import Runnable\n",
    "\n",
    "\n",
    "def parse_taxa(output_text: str) -> Dict:\n",
    "    \"\"\"Extract the taxonomy from the generated output.\"\"\"\n",
    "    cluster_matches = re.findall(\n",
    "        r\"\\s*<id>(.*?)</id>\\s*<name>(.*?)</name>\\s*<description>(.*?)</description>\\s*\",\n",
    "        output_text,\n",
    "        re.DOTALL,\n",
    "    )\n",
    "    clusters = [\n",
    "        {\"id\": id.strip(), \"name\": name.strip(), \"description\": description.strip()}\n",
    "        for id, name, description in cluster_matches\n",
    "    ]\n",
    "    # We don't parse the explanation since it isn't used downstream\n",
    "    return {\"clusters\": clusters}\n",
    "\n",
    "\n",
    "def format_docs(docs: List[Doc]) -> str:\n",
    "    xml_table = \"<conversations>\\n\"\n",
    "    for doc in docs:\n",
    "        xml_table += f'<conv_summ id={doc[\"id\"]}>{doc[\"summary\"]}</conv_summ>\\n'\n",
    "    xml_table += \"</conversations>\"\n",
    "    return xml_table\n",
    "\n",
    "\n",
    "def format_taxonomy(clusters):\n",
    "    xml = \"<cluster_table>\\n\"\n",
    "    for label in clusters:\n",
    "        xml += \"  <cluster>\\n\"\n",
    "        xml += f'    <id>{label[\"id\"]}</id>\\n'\n",
    "        xml += f'    <name>{label[\"name\"]}</name>\\n'\n",
    "        xml += f'    <description>{label[\"description\"]}</description>\\n'\n",
    "        xml += \"  </cluster>\\n\"\n",
    "    xml += \"</cluster_table>\"\n",
    "    return xml\n",
    "\n",
    "\n",
    "def invoke_taxonomy_chain(\n",
    "    chain: Runnable,\n",
    "    state: TaxonomyGenerationState,\n",
    "    config: RunnableConfig,\n",
    "    mb_indices: List[int],\n",
    ") -> TaxonomyGenerationState:\n",
    "    configurable = config[\"configurable\"]\n",
    "    docs = state[\"documents\"]\n",
    "    minibatch = [docs[idx] for idx in mb_indices]\n",
    "    data_table_xml = format_docs(minibatch)\n",
    "\n",
    "    previous_taxonomy = state[\"clusters\"][-1] if state[\"clusters\"] else []\n",
    "    cluster_table_xml = format_taxonomy(previous_taxonomy)\n",
    "\n",
    "    updated_taxonomy = chain.invoke(\n",
    "        {\n",
    "            \"data_xml\": data_table_xml,\n",
    "            \"use_case\": configurable[\"use_case\"],\n",
    "            \"cluster_table_xml\": cluster_table_xml,\n",
    "            \"suggestion_length\": configurable.get(\"suggestion_length\", 30),\n",
    "            \"cluster_name_length\": configurable.get(\"cluster_name_length\", 10),\n",
    "            \"cluster_description_length\": configurable.get(\n",
    "                \"cluster_description_length\", 30\n",
    "            ),\n",
    "            \"explanation_length\": configurable.get(\"explanation_length\", 20),\n",
    "            \"max_num_clusters\": configurable.get(\"max_num_clusters\", 25),\n",
    "        }\n",
    "    )\n",
    "\n",
    "    return {\n",
    "        \"clusters\": [updated_taxonomy[\"clusters\"]],\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e2a2723-d350-4871-83e8-88f081ab4c8b",
   "metadata": {},
   "source": [
    "#### 3. Generate initial taxonomy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "553dff30-ce53-47d8-ab3c-d2f437b7d5f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will share an LLM for each step of the generate -> update -> review cycle\n",
    "# You may want to consider using Opus or another more powerful model for this\n",
    "taxonomy_generation_llm = ChatAnthropic(\n",
    "    model=\"claude-3-haiku-20240307\", max_tokens_to_sample=2000\n",
    ")\n",
    "\n",
    "\n",
    "## Initial generation\n",
    "taxonomy_generation_prompt = hub.pull(\"wfh/tnt-llm-taxonomy-generation\").partial(\n",
    "    use_case=\"Generate the taxonomy that can be used to label the user intent in the conversation.\",\n",
    ")\n",
    "\n",
    "taxa_gen_llm_chain = (\n",
    "    taxonomy_generation_prompt | taxonomy_generation_llm | StrOutputParser()\n",
    ").with_config(run_name=\"GenerateTaxonomy\")\n",
    "\n",
    "\n",
    "generate_taxonomy_chain = taxa_gen_llm_chain | parse_taxa\n",
    "\n",
    "\n",
    "def generate_taxonomy(\n",
    "    state: TaxonomyGenerationState, config: RunnableConfig\n",
    ") -> TaxonomyGenerationState:\n",
    "    return invoke_taxonomy_chain(\n",
    "        generate_taxonomy_chain, state, config, state[\"minibatches\"][0]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8caefddd-c4c6-4318-972a-39c384183d79",
   "metadata": {},
   "source": [
    "#### 4. Update Taxonomy\n",
    "\n",
    "This is a \"critique -> revise\" step that is repeated N times.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b8739b5b-ba8a-4c40-bd25-a3b06a19949d",
   "metadata": {},
   "outputs": [],
   "source": [
    "taxonomy_update_prompt = hub.pull(\"wfh/tnt-llm-taxonomy-update\")\n",
    "\n",
    "taxa_update_llm_chain = (\n",
    "    taxonomy_update_prompt | taxonomy_generation_llm | StrOutputParser()\n",
    ").with_config(run_name=\"UpdateTaxonomy\")\n",
    "\n",
    "\n",
    "update_taxonomy_chain = taxa_update_llm_chain | parse_taxa\n",
    "\n",
    "\n",
    "def update_taxonomy(\n",
    "    state: TaxonomyGenerationState, config: RunnableConfig\n",
    ") -> TaxonomyGenerationState:\n",
    "    which_mb = len(state[\"clusters\"]) % len(state[\"minibatches\"])\n",
    "    return invoke_taxonomy_chain(\n",
    "        update_taxonomy_chain, state, config, state[\"minibatches\"][which_mb]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35f07f42-3025-446c-a6b0-2e45ea54f269",
   "metadata": {},
   "source": [
    "#### 5. Review Taxonomy\n",
    "\n",
    "This runs once we've processed all the minibatches.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0039cf1c-54d5-4e9e-8dd6-a5cebfaec92d",
   "metadata": {},
   "outputs": [],
   "source": [
    "taxonomy_review_prompt = hub.pull(\"wfh/tnt-llm-taxonomy-review\")\n",
    "\n",
    "taxa_review_llm_chain = (\n",
    "    taxonomy_review_prompt | taxonomy_generation_llm | StrOutputParser()\n",
    ").with_config(run_name=\"ReviewTaxonomy\")\n",
    "\n",
    "\n",
    "review_taxonomy_chain = taxa_review_llm_chain | parse_taxa\n",
    "\n",
    "\n",
    "def review_taxonomy(\n",
    "    state: TaxonomyGenerationState, config: RunnableConfig\n",
    ") -> TaxonomyGenerationState:\n",
    "    batch_size = config[\"configurable\"].get(\"batch_size\", 200)\n",
    "    original = state[\"documents\"]\n",
    "    indices = list(range(len(original)))\n",
    "    random.shuffle(indices)\n",
    "    return invoke_taxonomy_chain(\n",
    "        review_taxonomy_chain, state, config, indices[:batch_size]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae1d8103-3ecb-458c-8269-1f81c1c6296b",
   "metadata": {},
   "source": [
    "## Define the Graph\n",
    "\n",
    "With all the functionality defined, we can define the graph!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f1f97ea4-53e5-4f55-8d73-b5b2234a47d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import StateGraph\n",
    "\n",
    "graph = StateGraph(TaxonomyGenerationState)\n",
    "graph.add_node(\"summarize\", map_reduce_chain)\n",
    "graph.add_node(\"get_minibatches\", get_minibatches)\n",
    "graph.add_node(\"generate_taxonomy\", generate_taxonomy)\n",
    "graph.add_node(\"update_taxonomy\", update_taxonomy)\n",
    "graph.add_node(\"review_taxonomy\", review_taxonomy)\n",
    "\n",
    "graph.add_edge(\"summarize\", \"get_minibatches\")\n",
    "graph.add_edge(\"get_minibatches\", \"generate_taxonomy\")\n",
    "graph.add_edge(\"generate_taxonomy\", \"update_taxonomy\")\n",
    "\n",
    "\n",
    "def should_review(state: TaxonomyGenerationState) -> str:\n",
    "    num_minibatches = len(state[\"minibatches\"])\n",
    "    num_revisions = len(state[\"clusters\"])\n",
    "    if num_revisions < num_minibatches:\n",
    "        return \"update_taxonomy\"\n",
    "    return \"review_taxonomy\"\n",
    "\n",
    "\n",
    "graph.add_conditional_edges(\n",
    "    \"update_taxonomy\",\n",
    "    should_review,\n",
    "    # Optional (but required for the diagram to be drawn correctly below)\n",
    "    {\"update_taxonomy\": \"update_taxonomy\", \"review_taxonomy\": \"review_taxonomy\"},\n",
    ")\n",
    "graph.set_finish_point(\"review_taxonomy\")\n",
    "\n",
    "graph.set_entry_point(\"summarize\")\n",
    "app = graph.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cc4fcd31-a380-4eac-872a-42edd93736c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "\n",
    "Image(app.get_graph().draw_png())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8bdebf5-f315-4e96-80a2-5dde66b327c1",
   "metadata": {},
   "source": [
    "## Usage\n",
    "\n",
    "The docs can contain **any** content, but we've found it works really well on chat bot logs, such as those captured by [LangSmith](https://smith.langchain.com).\n",
    "\n",
    "We will use that as an example below. Update the `project_name` to your own LangSmith project.\n",
    "\n",
    "You will likely have to customize the `run_to_doc` function below, since your expected keys may differ from those of this notebook's author.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "bcc65649-157f-4848-9ef0-8a9932a98d85",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta\n",
    "\n",
    "from langsmith import Client\n",
    "\n",
    "project_name = \"YOUR PROJECT NAME\"  # Update to your own project\n",
    "client = Client()\n",
    "\n",
    "past_week = datetime.now() - timedelta(days=7)\n",
    "runs = list(\n",
    "    client.list_runs(\n",
    "        project_name=project_name,\n",
    "        filter=\"eq(is_root, true)\",\n",
    "        start_time=past_week,\n",
    "        # We only need to return the inputs + outputs\n",
    "        select=[\"inputs\", \"outputs\"],\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "# Convert the langsmith traces to our graph's Doc object.\n",
    "def run_to_doc(run) -> Doc:\n",
    "    turns = []\n",
    "    idx = 0\n",
    "    for turn in run.inputs.get(\"chat_history\") or []:\n",
    "        key, value = next(iter(turn.items()))\n",
    "        turns.append(f\"<{key} idx={idx}>\\n{value}\\n</{key}>\")\n",
    "        idx += 1\n",
    "    turns.append(\n",
    "        f\"\"\"\n",
    "<human idx={idx}>\n",
    "{run.inputs['question']}\n",
    "</human>\"\"\"\n",
    "    )\n",
    "    if run.outputs and run.outputs[\"output\"]:\n",
    "        turns.append(\n",
    "            f\"\"\"<ai idx={idx+1}>\n",
    "{run.outputs['output']}\n",
    "</ai>\"\"\"\n",
    "        )\n",
    "    return {\n",
    "        \"id\": str(run.id),\n",
    "        \"content\": (\"\\n\".join(turns)),\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "245ed4e4-c08d-4e47-90d5-b437b0532954",
   "metadata": {},
   "source": [
    "#### Invoke\n",
    "\n",
    "Now convert the runs to docs and kick off your graph flow. This will take some time! The summary step takes the longest. If you want to speed things up, you could try splitting the load across model providers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "900906b5-9264-46a8-ba83-46307f8c25d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.cache import InMemoryCache\n",
    "from langchain.globals import set_llm_cache\n",
    "\n",
    "# Optional. If you are running into errors or rate limits and want to avoid repeated computation,\n",
    "# you can set this while debugging\n",
    "\n",
    "set_llm_cache(InMemoryCache())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2340177-f40c-407a-8e3e-cb06c2ef09ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will randomly sample down to 1K docs to speed things up\n",
    "docs = [run_to_doc(run) for run in runs if run.inputs]\n",
    "docs = random.sample(docs, min(len(docs), 1000))\n",
    "use_case = (\n",
    "    \"Generate the taxonomy that can be used both to label the user intent\"\n",
    "    \" as well as to identify any required documentation (references, how-tos, etc.)\"\n",
    "    \" that would benefit the user.\"\n",
    ")\n",
    "\n",
    "stream = app.stream(\n",
    "    {\"documents\": docs},\n",
    "    {\n",
    "        \"configurable\": {\n",
    "            \"use_case\": use_case,\n",
    "            # Optional:\n",
    "            \"batch_size\": 400,\n",
    "            \"suggestion_length\": 30,\n",
    "            \"cluster_name_length\": 10,\n",
    "            \"cluster_description_length\": 30,\n",
    "            \"explanation_length\": 20,\n",
    "            \"max_num_clusters\": 25,\n",
    "        },\n",
    "        # We batch summarize the docs. To avoid getting errors, we will limit the\n",
    "        # degree of parallelism to permit.\n",
    "        \"max_concurrency\": 2,\n",
    "    },\n",
    ")\n",
    "\n",
    "for step in stream:\n",
    "    node, state = next(iter(step.items()))\n",
    "    print(node, str(state)[:20] + \" ...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46be818a-adda-4ecc-a798-7074eb1ec400",
   "metadata": {},
   "source": [
    "## Final Result\n",
    "\n",
    "Below, render the final result as markdown:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "38085515-6cda-452d-9f44-de440058cb3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## Final Taxonomy\n",
       "\n",
       "| ID | Name | Description |\n",
       "|----|------|-------------|\n",
       "| 1 | Troubleshooting Network Connectivity Issues | Resolving problems with DNS, network connections, and GitHub extension activation. |\n",
       "| 2 | Extracting and Analyzing Data | Retrieving and processing data from various sources like text files, databases, and APIs. |\n",
       "| 3 | Providing Healthcare Insights | Generating medical diagnosis, symptom checking, drug information, and skin condition analysis. |\n",
       "| 4 | Configuring and Optimizing Models | Adjusting model parameters and hyperparameters to improve performance for a given task. |\n",
       "| 5 | Generating Creative Poetry | Creating poems using language models and AI-powered tools. |\n",
       "| 6 | Interacting with Databases | Querying databases, extracting data, and managing errors during data processing. |\n",
       "| 7 | Querying Vector Databases | Interacting with vector databases like Milvus to store and retrieve high-dimensional data. |\n",
       "| 8 | Generating Synthetic Data | Creating synthetic data using language models and machine learning techniques. |\n",
       "| 9 | Integrating Tools and Workflows | Incorporating various tools and libraries into a cohesive workflow for different tasks. |\n",
       "| 10 | Improving Information Retrieval | Storing and querying multiple vectors per document for better semantic understanding. |\n",
       "| 11 | Processing Documents and Extracting Text | Parsing and extracting text from various document formats like PDF, DOCX, and HTML. |\n",
       "| 12 | Building Local Knowledge Bases | Creating knowledge bases from text files, handling text splitting, embeddings, and storage. |\n",
       "| 13 | Optimizing Conversational Retrieval | Troubleshooting and improving the performance of the ConversationalRetrievalChain in LangChain. |\n",
       "| 14 | Connecting Databases and Using Agents | Connecting to databases, using agents, and understanding the differences between agent types. |\n",
       "| 15 | Introspecting LangChain Tools | Accessing and retrieving details about the functions and source code of LangChain tools. |\n",
       "| 16 | Generating Styled Answers with Retrieval Augmentation | Creating a QA system that generates well-cited answers in a specific style. |\n",
       "| 17 | Using ZERO_SHOT_REACT_DESCRIPTION Agents | Applying the ZERO_SHOT_REACT_DESCRIPTION agent type in LangChain for chat models. |\n",
       "| 18 | Automating Microlearning Course Creation | Generating microlearning courses based on input parameters like topic, volume, and learning style. |\n",
       "| 19 | Integrating with Chroma Vector Store | Storing and retrieving data in the Chroma vector database, including handling document embeddings. |\n",
       "| 20 | Managing LangChain Callback Tokens | Understanding and utilizing the callback token feature in the LCEL chain. |\n",
       "| 21 | Troubleshooting FastAPI Deployments | Resolving issues with deploying a React app with a FastAPI backend. |\n",
       "| 22 | Analyzing Data with LangChain Agents | Using LangChain agents to interact with Pandas and Spark DataFrames for data exploration. |\n",
       "| 23 | Implementing the OpenAI Chat API | Implementing the OpenAI chat completion API and understanding the required inputs and outputs. |\n",
       "| 24 | Comparing LangChain and LLMIndex | Evaluating the differences between LangChain and LLMIndex, including their UI support for Markdown. |\n",
       "| 25 | Suppressing Tools in AgentExecutor | Temporarily disabling tools in an AgentExecutor for a fixed number of invocations. |\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown\n",
    "\n",
    "\n",
    "def format_taxonomy_md(clusters):\n",
    "    md = \"## Final Taxonomy\\n\\n\"\n",
    "    md += \"| ID | Name | Description |\\n\"\n",
    "    md += \"|----|------|-------------|\\n\"\n",
    "\n",
    "    # Fill the table with cluster data\n",
    "    for label in clusters:\n",
    "        id = label[\"id\"]\n",
    "        name = label[\"name\"].replace(\n",
    "            \"|\", \"\\\\|\"\n",
    "        )  # Escape any pipe characters within the content\n",
    "        description = label[\"description\"].replace(\n",
    "            \"|\", \"\\\\|\"\n",
    "        )  # Escape any pipe characters\n",
    "        md += f\"| {id} | {name} | {description} |\\n\"\n",
    "\n",
    "    return md\n",
    "\n",
    "\n",
    "Markdown(format_taxonomy_md(step[\"__end__\"][\"clusters\"][-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cf106db-6cff-4847-bff9-e25f00b9c015",
   "metadata": {},
   "source": [
    "## Phase 2: Labeling\n",
    "\n",
    "Now that we have our taxonomy, it's time to label a subset of our data to train a classifier.\n",
    "\n",
    "Input classification can be useful for anything from in-line prompt optimization (tailor the prompt for each classified intent), to system improvements (identifying categories for which the system doesn't produce good responses) to product analytics (understand which intent categories could be improved to drive profits).\n",
    "\n",
    "The problem is that LLM-based tagging can be expensive.\n",
    "\n",
    "Embeddings can be ~100x cheaper to compute, and a simple logistic regression classifier on top of that would add negligible cost.\n",
    "\n",
    "Let's tag and train a classifier!\n",
    "\n",
    "#### Label Training Data\n",
    "\n",
    "Use an LLM to label the data in a fully-automated fashion. For better accuracy, you can sample a portion of the results to label by hand as well to verify the quality.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "8aa8a6f5-f53a-41e5-b09d-c6e8476e5471",
   "metadata": {},
   "outputs": [],
   "source": [
    "labeling_prompt = hub.pull(\"wfh/tnt-llm-classify\")\n",
    "\n",
    "labeling_llm = ChatAnthropic(model=\"claude-3-haiku-20240307\", max_tokens_to_sample=2000)\n",
    "labeling_llm_chain = (labeling_prompt | labeling_llm | StrOutputParser()).with_config(\n",
    "    run_name=\"ClassifyDocs\"\n",
    ")\n",
    "\n",
    "\n",
    "def parse_labels(output_text: str) -> Dict:\n",
    "    \"\"\"Parse the generated labels from the predictions.\"\"\"\n",
    "    category_matches = re.findall(\n",
    "        r\"\\s*<category>(.*?)</category>.*\",\n",
    "        output_text,\n",
    "        re.DOTALL,\n",
    "    )\n",
    "    categories = [{\"category\": category.strip()} for category in category_matches]\n",
    "    if len(categories) > 1:\n",
    "        logger.warning(f\"Multiple selected categories: {categories}\")\n",
    "    label = categories[0]\n",
    "    stripped = re.sub(r\"^\\d+\\.\\s*\", \"\", label[\"category\"]).strip()\n",
    "    return {\"category\": stripped}\n",
    "\n",
    "\n",
    "labeling_chain = labeling_llm_chain | parse_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "59c06eea-ecbf-43af-a292-71816ccd92b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "final_taxonomy = step[\"__end__\"][\"clusters\"][-1]\n",
    "xml_taxonomy = format_taxonomy(final_taxonomy)\n",
    "results = labeling_chain.batch(\n",
    "    [\n",
    "        {\n",
    "            \"content\": doc[\"content\"],\n",
    "            \"taxonomy\": xml_taxonomy,\n",
    "        }\n",
    "        for doc in docs\n",
    "    ],\n",
    "    {\"max_concurrency\": 5},\n",
    "    return_exceptions=True,\n",
    ")\n",
    "# Update the docs to include the categories\n",
    "updated_docs = [{**doc, **category} for doc, category in zip(docs, results)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ef9be82-278e-4501-8af9-70409ce15cc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "if \"OPENAI_API_KEY\" not in os.environ:\n",
    "    os.environ[\"OPENAI_API_KEY\"] = getpass(\"Enter your OPENAI_API_KEY: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "c21f787e-2dcb-49c2-9cc1-5284a1732fbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_openai import OpenAIEmbeddings\n",
    "\n",
    "# Consider using other embedding models here too!\n",
    "encoder = OpenAIEmbeddings(model=\"text-embedding-3-large\")\n",
    "vectors = encoder.embed_documents([doc[\"content\"] for doc in docs])\n",
    "embedded_docs = [{**doc, \"embedding\": v} for doc, v in zip(updated_docs, vectors)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72284867-727d-467a-891a-7c7881967675",
   "metadata": {},
   "source": [
    "#### Train Classifier\n",
    "\n",
    "Now that we've extracted the features from the text, we can generate the classifier on them.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "eb19d42b-97c9-466b-b7b3-c17cc4db5180",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy: 0.515\n",
      "Test Accuracy: 0.330\n",
      "Train F1 Score: 0.493\n",
      "Test F1 Score: 0.335\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, f1_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.utils import class_weight\n",
    "\n",
    "# Create a dictionary mapping category names to their indices in the taxonomy\n",
    "category_to_index = {d[\"name\"]: i for i, d in enumerate(final_taxonomy)}\n",
    "category_to_index[\"Other\"] = len(category_to_index)\n",
    "# Convert category strings to numeric labels\n",
    "labels = [\n",
    "    category_to_index.get(d[\"category\"], category_to_index[\"Other\"])\n",
    "    for d in embedded_docs\n",
    "]\n",
    "\n",
    "label_vectors = [d[\"embedding\"] for d in embedded_docs]\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    label_vectors, labels, test_size=0.2, random_state=42\n",
    ")\n",
    "\n",
    "# Calculate class weights\n",
    "class_weights = class_weight.compute_class_weight(\n",
    "    class_weight=\"balanced\", classes=np.unique(y_train), y=y_train\n",
    ")\n",
    "class_weight_dict = dict(enumerate(class_weights))\n",
    "\n",
    "# Weight the classes to partially handle imbalanced data\n",
    "model = LogisticRegression(class_weight=class_weight_dict)\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "train_preds = model.predict(X_train)\n",
    "test_preds = model.predict(X_test)\n",
    "\n",
    "train_acc = accuracy_score(y_train, train_preds)\n",
    "test_acc = accuracy_score(y_test, test_preds)\n",
    "train_f1 = f1_score(y_train, train_preds, average=\"weighted\")\n",
    "test_f1 = f1_score(y_test, test_preds, average=\"weighted\")\n",
    "\n",
    "print(f\"Train Accuracy: {train_acc:.3f}\")\n",
    "print(f\"Test Accuracy: {test_acc:.3f}\")\n",
    "print(f\"Train F1 Score: {train_f1:.3f}\")\n",
    "print(f\"Test F1 Score: {test_f1:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32e7e994-a3c3-47f3-a860-32b847dfefee",
   "metadata": {},
   "source": [
    "## Phase 3: Deploy\n",
    "\n",
    "Now that you have your classifier, you can easily deploy it and apply to future runs! All you need is to embed the input and apply your LogisticRegression classifier. Let's try it. We will use python's [joblib](https://joblib.readthedocs.io/en/stable/) library to serialize our sklearn classifier. Below is an example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "c27cbb6b-4d0f-476a-bef3-31ed307ce45f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from joblib import dump as jl_dump\n",
    "\n",
    "categories = list(category_to_index)\n",
    "\n",
    "# Save the model and categories to a file\n",
    "with open(\"model.joblib\", \"wb\") as file:\n",
    "    jl_dump((model, categories), file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "443f5f92-7f3c-4ce8-9104-b2b32ace0c42",
   "metadata": {},
   "source": [
    "#### To deploy\n",
    "\n",
    "When deploying, you can load the classifier and initialize your embeddings encoder. They fit together easily using LCEL:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "28f0b88a-b308-4208-b482-6c157357dfc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from joblib import load as jl_load\n",
    "from langchain_openai import OpenAIEmbeddings\n",
    "\n",
    "loaded_model, loaded_categories = jl_load(\"model.joblib\")\n",
    "encoder = OpenAIEmbeddings(model=\"text-embedding-3-large\")\n",
    "\n",
    "\n",
    "def get_category_name(predictions):\n",
    "    return [loaded_categories[pred] for pred in predictions]\n",
    "\n",
    "\n",
    "classifier = (\n",
    "    RunnableLambda(encoder.embed_documents, encoder.aembed_documents)\n",
    "    | loaded_model.predict\n",
    "    | get_category_name\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3114657e-b558-4a72-91af-68ae3fccacd7",
   "metadata": {},
   "source": [
    "#### Example:\n",
    "\n",
    "Assuming you've had some more data come in, you can fetch it and apply it below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "6cdb9d8a-2aa1-4f48-8b23-f311fdf36416",
   "metadata": {},
   "outputs": [],
   "source": [
    "client = Client()\n",
    "\n",
    "past_5_min = datetime.now() - timedelta(minutes=5)\n",
    "runs = list(\n",
    "    client.list_runs(\n",
    "        project_name=project_name,\n",
    "        filter=\"eq(is_root, true)\",\n",
    "        start_time=past_5_min,\n",
    "        # We only need to return the inputs + outputs\n",
    "        select=[\"inputs\", \"outputs\"],\n",
    "        limit=100,\n",
    "    )\n",
    ")\n",
    "docs = [run_to_doc(r) for r in runs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "b154439b-902e-42f3-afbc-89edb0cfea81",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/embeddings \"HTTP/1.1 200 OK\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Interacting with Databases', 'Optimizing Conversational Retrieval']\n"
     ]
    }
   ],
   "source": [
    "classes = classifier.invoke([doc[\"content\"] for doc in docs])\n",
    "print(classes[:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe415d54-fa94-4c62-b68b-d4437c446d42",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "Congrats on implementing TNT-LLM! While most folks use clustering-based approaches like LDA, k-means, etc. it can often be hard to really interpret what each cluster represents. TNT-LLM generates human-interpretable labels you can use downstream to monitor and improve your application.\n",
    "\n",
    "The technique also lends itself to hierarchical sub-categorizing: once you have the above taxonomy, use it to label your data, then on each sub-category, generate a new taxonomy using a similar technique to the one described above!\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
